/*
 *
 *  Copyright (C) 2007-2020 SimplyCore, LLC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *
 */

#ifdef _USBD_ENABLE_STUB_
#include "usbd.h"
#include "loader.h"
struct IIIlll*IIlllIlI;struct list_head llllIllI;struct mutex lIlIIllI;struct 
list_head lIlIllIl;struct mutex lIlIIIll;struct list_head IllllIIl;struct mutex 
llIIllIl;extern struct usb_driver lIIlIIl;int IlllIIlI(struct usb_device*IIIlI){
IlllIl vid,IIllIll,Illllll;lIllIl class,lIlIIllIl,IllllllII;struct IllIlIII*
IIIIl;int IIIIlllll=(0xd4+6526-0x1a52);int IlIlIllI=(0x187b+2600-0x22a3);const 
char*lIlIl=NULL;const char*serial=NULL;const char*lIIlIlI=NULL;lIIIl(
"\x2b\x2b" "\n");
if(strcmp(IlIllIlI(IIIlI),lIIllll)==(0x5ea+5462-0x1b40)){lIIIl(
"\x2d\x2d\x20\x73\x6b\x69\x70\x20\x6f\x75\x72\x20\x76\x69\x72\x74\x75\x61\x6c\x20\x64\x65\x76\x69\x63\x65\x21" "\n"
);return(0x1383+1529-0x197c);}vid=le16_to_cpu(IIIlI->descriptor.idVendor);
IIllIll=le16_to_cpu(IIIlI->descriptor.idProduct);Illllll=le16_to_cpu(IIIlI->
descriptor.bcdDevice);lIIIlllII(IIIlI,&class,&lIlIIllIl,&IllllllII);if(class==
(0x1753+2292-0x203e)){lIIIl(
"\x2d\x2d\x20\x73\x6b\x69\x70\x20\x75\x73\x62\x20\x68\x75\x62\x21" "\n");return
(0x1e7b+1055-0x229a);}if(IIlIIIll(IIIlI,&lIlIl,&serial,&lIIlIlI)){lIIIl(
"\x2d\x2d\x20\x63\x61\x6e\x20\x6e\x6f\x74\x20\x67\x65\x74\x20\x69\x6e\x73\x74\x61\x6e\x63\x65\x69\x64\x21" "\n"
);return(0x4cd+3419-0x1228);}lIIIl(
"\x56\x3d\x25\x30\x34\x58\x20\x50\x3d\x25\x30\x34\x58\x20\x52\x3d\x25\x30\x34\x58\x20\x43\x3d\x25\x30\x32\x58\x20\x53\x3d\x25\x30\x32\x58\x20\x50\x3d\x25\x30\x32\x58\x20\x49\x44\x3d\x25\x73\x20\x53\x4e\x3d\x25\x73\x20\x49\x4e\x3d\x25\x73" "\n"
,vid,IIllIll,Illllll,class,lIlIIllIl,IllllllII,lIlIl?lIlIl:"\x6e\x6f\x6e\x65",
serial?serial:"\x6e\x6f\x6e\x65",lIIlIlI?lIIlIlI:"\x6e\x6f\x6e\x65");
mutex_lock(&lIlIIllI);list_for_each_entry(IIIIl,&llllIllI,entry){if(IIIIl->IIIIl
.IIIlIIl&lIllllIlI){if(IIIIl->IIIIl.lIllllII!=vid){continue;}}if(IIIIl->IIIIl.
IIIlIIl&IlIlIlIII){if(IIIIl->IIIIl.IllIIllI!=IIllIll){continue;}}if(IIIIl->IIIIl
.IIIlIIl&lIlIlIIII){if(IIIIl->IIIIl.IlIIllIl!=Illllll){continue;}}if(IIIIl->
IIIIl.IIIlIIl&IIIlIIllll){if(IIIIl->IIIIl.llIlIlII!=class){continue;}}if(IIIIl->
IIIIl.IIIlIIl&IIlIIIlll){if(IIIIl->IIIIl.lIlllllI!=lIlIIllIl){continue;}}if(
IIIIl->IIIIl.IIIlIIl&IlIllllIl){if(IIIIl->IIIIl.IlllIlII!=IllllllII){continue;}}
if(IIIIl->IIIIl.IIIlIIl&IlIlllIlI){if(lIlIl==NULL){continue;}if(strncmp((char*)(
&IIIIl->IIIIl+(0x890+2345-0x11b8)),lIlIl,IIIIl->IIIIl.IIlIIIl)){continue;}}if(
IIIIl->IIIIl.IIIlIIl&IIIlIIllI){if(serial==NULL){continue;}if(strncmp((char*)(&
IIIIl->IIIIl+(0x12b9+3407-0x2007))+IIIIl->IIIIl.IIlIIIl,serial,IIIIl->IIIIl.
IIIlllIl)){continue;}}if(IIIIl->IIIIl.IIIlIIl&lIIllIIll){if(lIIlIlI==NULL){
continue;}lIIIl(
"\x63\x68\x65\x63\x6b\x20\x69\x6e\x74\x73\x61\x6e\x63\x65\x20\x69\x64\x20\x25\x73\x20\x76\x73\x20\x25\x73" "\n"
,lIIlIlI,(char*)(&IIIIl->IIIIl+(0x5c3+826-0x8fc))+IIIIl->IIIIl.IIlIIIl+IIIIl->
IIIIl.IIIlllIl);if(strncmp((char*)(&IIIIl->IIIIl+(0x198+775-0x49e))+IIIIl->IIIIl
.IIlIIIl+IIIIl->IIIIl.IIIlllIl,lIIlIlI,IIIIl->IIIIl.IlllIlIl)){lIIIl(
"\x6e\x6f\x74\x20\x6d\x61\x74\x63\x68\x65\x64\x20\x69\x6e\x74\x73\x61\x6e\x63\x65\x20\x69\x64" "\n"
);continue;}}if(IIIIl->IIIIl.IIIlIIl&IlIIlIllI){IlIlIllI=(0xa15+4243-0x1aa7);
IIIIlllll=(0x16ff+200-0x17c6);break;}if(IIIIl->IIIIl.IIIlIIl&IIIlIlIlI){IlIlIllI
=(0xa+9580-0x2576);IIIIlllll=(0x14c+6716-0x1b87);break;}}mutex_unlock(&lIlIIllI)
;if(IIIIlllll==(0x77f+3838-0x167d)){lIIIl(
"\x2d\x2d\x20\x6e\x6f\x20\x6d\x61\x74\x63\x68" "\n");}else if(IlIlIllI){lIIIl(
"\x2d\x2d\x20\x61\x6c\x6c\x6f\x77\x65\x64" "\n");}else{lIIIl(
"\x2d\x2d\x20\x64\x65\x6e\x69\x65\x64" "\n");}return IlIlIllI;}void llllIllII(
struct list_head*lIlIllII){struct list_head Illlll=LIST_HEAD_INIT(Illlll);

mutex_lock(&lIlIIllI);list_splice_init(&llllIllI,&Illlll);list_splice_init(
lIlIllII,&llllIllI);mutex_unlock(&lIlIIllI);
while(!list_empty(&Illlll)){struct IllIlIII*lIlIIll;lIlIIll=list_entry(Illlll.
next,struct IllIlIII,entry);list_del(&lIlIIll->entry);lIlIll(lIlIIll);}



}void IIlIIlII(){struct list_head Illlll=LIST_HEAD_INIT(Illlll);
mutex_lock(&lIlIIllI);list_splice_init(&llllIllI,&Illlll);mutex_unlock(&lIlIIllI
);
while(!list_empty(&Illlll)){struct IllIlIII*lIlIIll;lIlIIll=list_entry(Illlll.
next,struct IllIlIII,entry);list_del(&lIlIIll->entry);lIlIll(lIlIIll);}}lllII 
IlIlllIIl(struct usb_device*IIIlI){struct IllIIIll*IlIlIIll;lllII IlIllIl=
(0x188d+2833-0x239e);mutex_lock(&llIIllIl);list_for_each_entry(IlIlIIll,&
IllllIIl,entry){if(IlIlIIll->lllIlII.lIllllII!=le16_to_cpu(IIIlI->descriptor.
idVendor)){continue;}if(IlIlIIll->lllIlII.IllIIllI!=le16_to_cpu(IIIlI->
descriptor.idProduct)){continue;}IlIllIl=IlIlIIll->lllIlII.lIIIlIlll;break;}
mutex_unlock(&llIIllIl);return IlIllIl;}void lllllIllI(struct list_head*IlIlIIlI
){struct list_head Illlll=LIST_HEAD_INIT(Illlll);

mutex_lock(&llIIllIl);list_splice_init(&IllllIIl,&Illlll);list_splice_init(
IlIlIIlI,&IllllIIl);mutex_unlock(&llIIllIl);
while(!list_empty(&Illlll)){struct IllIIIll*lIlIIll;lIlIIll=list_entry(Illlll.
next,struct IllIIIll,entry);list_del(&lIlIIll->entry);lIlIll(lIlIIll);}}void 
llIIlllIl(){struct list_head Illlll=LIST_HEAD_INIT(Illlll);
mutex_lock(&llIIllIl);list_splice_init(&IllllIIl,&Illlll);mutex_unlock(&llIIllIl
);
while(!list_empty(&Illlll)){struct IllIIIll*lIlIIll;lIlIIll=list_entry(Illlll.
next,struct IllIIIll,entry);list_del(&lIlIIll->entry);lIlIll(lIlIIll);}}



int IIlIIIll(struct usb_device*llIII,const char**IIIlIIlII,const char**IlllIllll
,const char**llIllIlll){struct IllIIlll*IIIIII=NULL;struct IllIIlll*IllIllIl;
mutex_lock(&lIlIIIll);list_for_each_entry(IllIllIl,&lIlIllIl,entry){if(IllIllIl
->IIIlI==llIII){IIIIII=IllIllIl;break;}}if(!IIIIII){IIIIII=IlllIIl(sizeof(struct
 IllIIlll),GFP_KERNEL);if(!IIIIII){mutex_unlock(&lIlIIIll);return-ENOMEM;}IIIIII
->IIIlI=usb_get_dev(llIII);IIIIII->lIlIl=llIIIl(&IIIIII->IIIlI->dev);IIIIII->
serial=llIII->serial;if(IIIIII->serial&&*IIIIII->serial&&(IlIlllIIl(llIII)&
llIIIIllIl)==(0x1105+3453-0x1e82)){const char*lIllIIIl=IIIIII->serial;




while(*lIllIIIl>'\x20'&&*lIllIIIl<='\x7F'&&*lIllIIIl!='\x2C'){lIllIIIl++;}if(*
lIllIIIl){
IIIIII->lIIlIlI=IIIIII->lIlIl;}else{
IIIIII->lIIlIlI=IIIIII->serial;


list_for_each_entry(IllIllIl,&lIlIllIl,entry){if(IllIllIl->IIIlI->serial&&
IllIllIl->IIIlI->descriptor.idVendor==llIII->descriptor.idVendor&&IllIllIl->
IIIlI->descriptor.idProduct==llIII->descriptor.idProduct&&strcmp(IllIllIl->IIIlI
->serial,llIII->serial)==(0x134+3482-0xece)){
IIIIII->lIIlIlI=IIIIII->lIlIl;break;}}}}else{
IIIIII->lIIlIlI=IIIIII->lIlIl;}list_add_tail(&IIIIII->entry,&lIlIllIl);}


*IIIlIIlII=IIIIII->lIlIl;*IlllIllll=IIIIII->serial;*llIllIlll=IIIIII->lIIlIlI;
mutex_unlock(&lIlIIIll);return(0x7af+2632-0x11f7);}void llllIIIlI(struct 
usb_device*IIIlI){struct IllIIlll*IIIIII;lIIIl("\x2b\x2b" "\n");mutex_lock(&
lIlIIIll);list_for_each_entry(IIIIII,&lIlIllIl,entry){if(IIIIII->IIIlI==IIIlI){
list_del(&IIIIII->entry);usb_put_dev(IIIIII->IIIlI);lIlIll(IIIIII);break;}}
mutex_unlock(&lIlIIIll);}void IIllllIlI(){struct list_head Illlll=LIST_HEAD_INIT
(Illlll);
mutex_lock(&lIlIIIll);list_splice_init(&lIlIllIl,&Illlll);mutex_unlock(&lIlIIIll
);
while(!list_empty(&Illlll)){struct IllIIlll*IIIIII;IIIIII=list_entry(Illlll.next
,struct IllIIlll,entry);list_del(&IIIIII->entry);usb_put_dev(IIIIII->IIIlI);
lIlIll(IIIIII);}}











int llIIIlIIl(struct usb_interface*IlIlIl){int IlIlI;int IlIlIIllI=
(0x1411+4282-0x24cb);int llIllllI=(0x10b+7231-0x1d4a);
if(IlIlIl->dev.driver&&to_usb_driver(IlIlIl->dev.driver)==&lIIlIIl){return
(0xbcb+5896-0x22d3);}
llIllllI=(0x9d7+5058-0x1d98);
if(IlIlIl->dev.driver){usb_driver_release_interface(to_usb_driver(IlIlIl->dev.
driver),IlIlIl);IlIlIIllI=(0x1d52+1705-0x23fa);}
IlIlI=usb_driver_claim_interface(&lIIlIIl,IlIlIl,(void*)-(0xe8f+4349-0x1f8b));if
(IlIlI<(0x7e4+4103-0x17eb)){IIllIl(
"\x66\x61\x69\x6c\x65\x64\x20\x74\x6f\x20\x63\x6c\x61\x69\x6d\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x2c\x20\x65\x72\x72\x6f\x72\x20\x25\x64" "\n"
,llIIIl(&IlIlIl->dev),IlIlI);return IlIlI;}IlIlI=lIlIIIllI(IlIlIl,IlIlIIllI);if(
IlIlI<(0x113+343-0x26a)){IIllIl(
"\x66\x61\x69\x6c\x65\x64\x20\x74\x6f\x20\x61\x74\x74\x61\x63\x68\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x2c\x20\x65\x72\x72\x6f\x72\x20\x25\x64" "\n"
,llIIIl(&IlIlIl->dev),IlIlI);
usb_driver_release_interface(&lIIlIIl,IlIlIl);return IlIlI;}return llIllllI;}
#if KERNEL_GT_EQ((0x7e3+7635-0x25b1),(0xa34+1941-0x11c6),(0x6c+2063-0x87b))
static int lIIIIlllI(struct device*dev,const void*IlllIllII)
#else
static int lIIIIlllI(struct device*dev,void*IlllIllII)
#endif
{const char*lIlIl=IlllIllII;if(strcmp(lIlIl,llIIIl(dev))==(0x707+3714-0x1589)){
return(0x1633+4298-0x26fc);}return(0x523+7431-0x222a);}struct usb_device*
IllIllII(const char*lIlIl){struct device*dev;dev=bus_find_device(
#if KERNEL_LT_EQ((0x958+4155-0x1991),(0xefc+377-0x106f),(0x1512+2194-0x1d92))
lIIlIIl.driver.bus,
#else
lIIlIIl.drvwrap.driver.bus,
#endif
NULL,(void*)lIlIl,lIIIIlllI);if(dev){return to_usb_device(dev);}return NULL;}





int IIIIIlII(struct usb_device*IIIlI){int i;int IlIlIIIlI=(0x4dc+938-0x886);int 
llIllllI=(0x136+7357-0x1df3);int IlIlI=-ENODEV;lIIIl("\x2b\x2b\x20\x25\x73" "\n"
,llIIIl(&IIIlI->dev));if(!IIIlIIIl(IIIlI)){IlIlI=IllllIll(IIIlI);if(IlIlI<
(0x688+842-0x9d2)){IIllIl(
"\x66\x61\x69\x6c\x65\x64\x20\x74\x6f\x20\x61\x74\x74\x61\x63\x68\x20\x75\x73\x62\x20\x64\x65\x76\x69\x63\x65\x20\x25\x73\x2c\x20\x65\x72\x72\x6f\x72\x20\x25\x64" "\n"
,llIIIl(&IIIlI->dev),IlIlI);lIIIl(
"\x2d\x2d\x20\x72\x65\x73\x75\x6c\x74\x3d\x25\x64" "\n",IlIlI);return IlIlI;}}if
(IIIlI->actconfig){for(i=(0x606+1611-0xc51);i<IIIlI->actconfig->desc.
bNumInterfaces;i++){struct usb_interface*IlIlIl=IIIlI->actconfig->interface[i];
if(IlIlIl==NULL){continue;
}IlIlI=llIIIlIIl(IlIlIl);if(IlIlI<(0x421+5615-0x1a10)){lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x20\x6e\x6f\x74\x20\x63\x6c\x61\x69\x6d\x65\x64\x2c\x20\x65\x72\x72\x6f\x72\x20\x25\x64" "\n"
,llIIIl(&IlIlIl->dev),IlIlI);break;}IlIlIIIlI++;if(IlIlI>(0x11aa+3228-0x1e46)){
lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x2c\x20\x61\x63\x74\x75\x61\x6c\x6c\x79\x20\x63\x6c\x61\x69\x6d\x65\x64" "\n"
,llIIIl(&IlIlIl->dev));llIllllI++;}else
{lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x2c\x20\x63\x6c\x61\x69\x6d\x65\x64" "\n"
,llIIIl(&IlIlIl->dev));}}if(IlIlI>=(0x44c+6729-0x1e95)&&IlIlIIIlI>
(0x3d8+3556-0x11bc)&&llIllllI==(0x9fb+4249-0x1a94)){



struct IIlll*IIIll=IllIIIIl(IIIlI);if(IIIll){lIIIl(
"\x72\x65\x66\x72\x65\x73\x68\x20\x6f\x6e\x6c\x69\x6e\x65" "\n");IlIIlIlll(IIIll
);lllllIll(IIIll);}else{lIIIl(
"\x73\x74\x75\x62\x20\x6e\x6f\x74\x20\x66\x6f\x75\x6e\x64" "\n");}}}lIIIl(
"\x2d\x2d\x20\x72\x65\x73\x75\x6c\x74\x3d\x25\x64" "\n",IlIlI);return IlIlI;}





void lllIllIl(struct usb_device*IIIlI,int IlIIIIlI){int i;lIIIl(
"\x2b\x2b\x20\x25\x73" "\n",llIIIl(&IIIlI->dev));if(IIIlI->actconfig){for(i=
(0x1236+3608-0x204e);i<IIIlI->actconfig->desc.bNumInterfaces;i++){struct 
usb_interface*IlIlIl=IIIlI->actconfig->interface[i];if(IlIlIl==NULL){continue;
}if(IlIlIl->dev.driver==NULL){continue;}if(to_usb_driver(IlIlIl->dev.driver)!=&
lIIlIIl){continue;}lIIIl(
"\x72\x65\x6c\x65\x61\x73\x65\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73" "\n"
,llIIIl(&IlIlIl->dev));
usb_driver_release_interface(&lIIlIIl,IlIlIl);}}if(IIIlIIIl(IIIlI)){IllIllll(
IIIlI);}
#if KERNEL_GT_EQ((0x1740+2694-0x21c4),(0x1e04+2112-0x263e),(0x58+1908-0x7b6))
if(lIIlIllI(&IIIlI->dev)){IllIlIlI(&IIIlI->dev,(0x2102+372-0x2276));lIIIl(
"\x73\x65\x6e\x64\x20\x4b\x4f\x42\x4a\x5f\x41\x44\x44\x20\x66\x6f\x72\x20\x64\x65\x76\x69\x63\x65\x20\x25\x73" "\n"
,llIIIl(&IIIlI->dev));kobject_uevent(&IIIlI->dev.kobj,KOBJ_ADD);}
#endif
if(IIIlI->actconfig){for(i=(0x75d+7701-0x2572);i<IIIlI->actconfig->desc.
bNumInterfaces;i++){struct usb_interface*IlIlIl=IIIlI->actconfig->interface[i];
if(IlIlIl==NULL){continue;}
#if KERNEL_GT_EQ((0xa2b+7202-0x264b),(0x286+1607-0x8c7),(0xc81+2580-0x167f))
if(lIIlIllI(&IlIlIl->dev)){IllIlIlI(&IlIlIl->dev,(0xc53+47-0xc82));lIIIl(
"\x73\x65\x6e\x64\x20\x4b\x4f\x42\x4a\x5f\x41\x44\x44\x20\x66\x6f\x72\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73" "\n"
,llIIIl(&IlIlIl->dev));kobject_uevent(&IlIlIl->dev.kobj,KOBJ_ADD);}
#endif
if(IlIIIIlI&&IlIlIl->dev.driver==NULL){int IlIlIlII;lIIIl(
"\x6c\x6f\x61\x64\x20\x64\x65\x66\x61\x75\x6c\x74\x20\x64\x72\x69\x76\x65\x72\x20\x66\x6f\x72\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73" "\n"
,llIIIl(&IlIlIl->dev));


IlIlIlII=device_attach(&IlIlIl->dev);}}}lIIIl("\x2d\x2d" "\n");}








#if KERNEL_LT_EQ((0x1fb1+190-0x206d),(0x1e58+2180-0x26d6),(0x91f+2414-0x127a))


int llllllIIl(struct notifier_block*self,unsigned long IlIIllI,void*dev){struct 
usb_device*IIIlI=dev;lIIIl(
"\x2b\x2b\x20\x61\x63\x74\x69\x6f\x6e\x3d\x25\x73\x28\x25\x6c\x75\x29\x20\x64\x65\x76\x3d\x25\x73" "\n"
,IIllIlIIl(IlIIllI),IlIIllI,IIIlI?llIIIl(&IIIlI->dev):"\x6e\x6f\x6e\x65");if(
IlIIllI==USB_DEVICE_ADD){if(IlllIIlI(IIIlI)){
IIIIIlII(IIIlI);}}if(IlIIllI==USB_DEVICE_REMOVE){


lllIllIl(IIIlI,(0x39b+3481-0x1134));
llllIIIlI(IIIlI);}lIIIl("\x2d\x2d");return NOTIFY_OK;}struct notifier_block 
llIIIIII={.notifier_call=llllllIIl,.priority=INT_MAX,
};
#else 




int lllIIlIll(struct notifier_block*self,unsigned long IlIIllI,void*dev){struct 
device*IIIlIl=dev;lIIIl(
"\x2b\x2b\x20\x61\x63\x74\x69\x6f\x6e\x3d\x25\x73\x28\x25\x6c\x75\x29\x20\x64\x65\x76\x3d\x25\x73" "\n"
,IIIIIIIll(IlIIllI),IlIIllI,IIIlIl?llIIIl(IIIlIl):"\x6e\x6f\x6e\x65");if(IlIIllI
==BUS_NOTIFY_ADD_DEVICE){if(llIIIIllI(IIIlIl)){struct usb_device*IIIlI=
to_usb_device(IIIlIl);



if(IlllIIlI(IIIlI)){

if(IllllIll(IIIlI)>=(0x366+414-0x504)){
#if KERNEL_GT_EQ((0xf93+4940-0x22dd),(0x14df+971-0x18a4),(0xf32+2202-0x17b6))







IllIlIlI(&IIIlI->dev,(0x11f7+4290-0x22b8));
#endif
}}}else if(IIlIIlIlI(IIIlIl)){struct usb_interface*IlIlIl=to_usb_interface(dev);
struct usb_device*IIIlI=interface_to_usbdev(IlIlIl);
if(IIIlIIIl(IIIlI)){int IlIlI;
#if KERNEL_GT_EQ((0x849+7587-0x25ea),(0x31b+8417-0x23f6),(0xd3+1221-0x57e)) && \
KERNEL_LT_EQ((0x227a+196-0x233c),(0x1b78+866-0x1ed4),(0x230c+797-0x2602))
int state_in_sysfs;
#endif
#if KERNEL_GT_EQ((0x115d+1619-0x17ae),(0x5fa+4039-0x15bb),(0x329+5967-0x1a62))
IllIlIlI(&IlIlIl->dev,(0x1309+3401-0x2051));
#endif
lIIIl(
"\x63\x6c\x61\x69\x6d\x69\x6e\x67\x20\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73" "\n"
,llIIIl(&IlIlIl->dev));
#if KERNEL_GT_EQ((0x1704+4087-0x26f9),(0xf4+4681-0x1337),(0x578+2219-0xe09)) && \
KERNEL_LT_EQ((0x873+7240-0x24b9),(0x1eeb+1668-0x2569),(0x6f6+2593-0x10f0))























state_in_sysfs=IIIlIl->kobj.state_in_sysfs;IIIlIl->kobj.state_in_sysfs=
(0x19a2+3169-0x2603);
#endif
IlIlI=llIIIlIIl(IlIlIl);
#if KERNEL_GT_EQ((0x17dd+1923-0x1f5e),(0x777+7897-0x264a),(0xf87+4150-0x1fa3)) \
&& KERNEL_LT_EQ((0x188c+2756-0x234e),(0x2eb+1880-0xa3d),(0x12aa+4776-0x252b))

IIIlIl->kobj.state_in_sysfs=state_in_sysfs;
#endif
if(IlIlI<(0xdf1+2372-0x1735)){lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x20\x6e\x6f\x74\x20\x63\x6c\x61\x69\x6d\x65\x64\x2c\x20\x65\x72\x72\x6f\x72\x20\x25\x64" "\n"
,llIIIl(&IlIlIl->dev),IlIlI);}else if(IlIlI>(0x49c+4366-0x15aa)){lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x20\x61\x63\x74\x75\x61\x6c\x6c\x79\x20\x63\x6c\x61\x69\x6d\x65\x64" "\n"
,llIIIl(&IlIlIl->dev));}else
{lIIIl(
"\x69\x6e\x74\x65\x72\x66\x61\x63\x65\x20\x25\x73\x20\x63\x6c\x61\x69\x6d\x65\x64" "\n"
,llIIIl(&IlIlIl->dev));}}}}else if(IlIIllI==BUS_NOTIFY_DEL_DEVICE){if(IIlIIlIlI(
IIIlIl)){struct usb_interface*IlIlIl=to_usb_interface(dev);struct usb_device*
IIIlI=interface_to_usbdev(IlIlIl);if(IIIlIIIl(IIIlI)){



}}else if(llIIIIllI(IIIlIl)){struct usb_device*IIIlI=to_usb_device(IIIlIl);if(
IIIlIIIl(IIIlI)){


IllIllll(IIIlI);}
llllIIIlI(IIIlI);}}lIIIl("\x2d\x2d" "\n");return NOTIFY_OK;}struct 
notifier_block lIIlIIlI={.notifier_call=lllIIlIll,.priority=INT_MAX,
};
#endif 
#endif 

